return;
/* get the state value */
- xenbus_transaction_start("cpu");
err = xenbus_scanf(dir, "availability", "%s", state);
- xenbus_transaction_end(0);
if (err != 1) {
printk(KERN_ERR
int err;
again:
- err = xenbus_transaction_start("control");
+ err = xenbus_transaction_start();
if (err)
return;
str = (char *)xenbus_read("control", "shutdown", NULL);
xenbus_write("control", "shutdown", "");
err = xenbus_transaction_end(0);
- if (err == -ETIMEDOUT) {
+ if (err == -EAGAIN) {
kfree(str);
goto again;
}
int err;
again:
- err = xenbus_transaction_start("control");
+ err = xenbus_transaction_start();
if (err)
return;
if (!xenbus_scanf("control", "sysrq", "%c", &sysrq_key)) {
xenbus_printf("control", "sysrq", "%c", '\0');
err = xenbus_transaction_end(0);
- if (err == -ETIMEDOUT)
+ if (err == -EAGAIN)
goto again;
if (sysrq_key != '\0') {
return;
}
+again:
/* Supply the information about the device the frontend needs */
- err = xenbus_transaction_start(be->dev->nodename);
+ err = xenbus_transaction_start();
if (err) {
xenbus_dev_error(be->dev, err, "starting transaction");
return;
goto abort;
}
- xenbus_transaction_end(0);
+ err = xenbus_transaction_end(0);
+ if (err == EAGAIN)
+ goto again;
+ if (err) {
+ xenbus_dev_error(be->dev, err, "ending transaction",
+ ring_ref, evtchn);
+ goto abort;
+ }
+
xenbus_dev_ok(be->dev);
return;
goto out;
}
- err = xenbus_transaction_start(dev->nodename);
+again:
+ err = xenbus_transaction_start();
if (err) {
xenbus_dev_error(dev, err, "starting transaction");
goto destroy_blkring;
err = xenbus_transaction_end(0);
if (err) {
+ if (err == EAGAIN)
+ goto again;
xenbus_dev_error(dev, err, "completing transaction");
goto destroy_blkring;
}
goto out;
}
- err = xenbus_transaction_start(dev->nodename);
+again:
+ err = xenbus_transaction_start();
if (err) {
xenbus_dev_error(dev, err, "starting transaction");
goto destroy_ring;
err = xenbus_transaction_end(0);
if (err) {
+ if (err == EAGAIN)
+ goto again;
xenbus_dev_error(dev, err, "completing transaction");
goto destroy_ring;
}
/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
- * Transaction only applies to the given subtree.
* You can only have one transaction at any time.
*/
-int xenbus_transaction_start(const char *subtree)
+int xenbus_transaction_start(void)
{
- return xs_error(xs_single(XS_TRANSACTION_START, subtree, NULL));
+ return xs_error(xs_single(XS_TRANSACTION_START, "", NULL));
}
EXPORT_SYMBOL(xenbus_transaction_start);
int xenbus_mkdir(const char *dir, const char *node);
int xenbus_exists(const char *dir, const char *node);
int xenbus_rm(const char *dir, const char *node);
-int xenbus_transaction_start(const char *subtree);
+int xenbus_transaction_start(void);
int xenbus_transaction_end(int abort);
/* Single read and scanf: returns -errno or num scanned if > 0. */
}
#define xspy_transaction_start_doc "\n" \
- "Start a transaction on a path.\n" \
+ "Start a transaction.\n" \
"Only one transaction can be active at a time.\n" \
- " path [string]: xenstore path.\n" \
"\n" \
"Returns None on success.\n" \
"Raises RuntimeError on error.\n" \
static PyObject *xspy_transaction_start(PyObject *self, PyObject *args,
PyObject *kwds)
{
- static char *kwd_spec[] = { "path", NULL };
- static char *arg_spec = "s|";
+ static char *kwd_spec[] = { NULL };
+ static char *arg_spec = "";
char *path = NULL;
struct xs_handle *xh = xshandle(self);
if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_spec, kwd_spec, &path))
goto exit;
Py_BEGIN_ALLOW_THREADS
- xsval = xs_transaction_start(xh, path);
+ xsval = xs_transaction_start(xh);
Py_END_ALLOW_THREADS
if (!xsval) {
PyErr_SetFromErrno(PyExc_RuntimeError);
"Attempts to commit the transaction unless abort is true.\n" \
" abort [int]: abort flag (default 0).\n" \
"\n" \
- "Returns None on success.\n" \
+ "Returns True on success, False if you need to try again.\n" \
"Raises RuntimeError on error.\n" \
"\n"
xsval = xs_transaction_end(xh, abort);
Py_END_ALLOW_THREADS
if (!xsval) {
+ if (errno == EAGAIN) {
+ Py_INCREF(Py_False);
+ val = Py_False;
+ goto exit;
+ }
PyErr_SetFromErrno(PyExc_RuntimeError);
goto exit;
}
- Py_INCREF(Py_None);
- val = Py_None;
+ Py_INCREF(Py_True);
+ val = Py_True;
exit:
return val;
}
"""Release all vm devices.
"""
- t = xstransact("%s/device" % self.path)
-
- for n in controllerClasses.keys():
- for d in t.list(n):
- try:
- t.remove(d)
- except ex:
- # Log and swallow any exceptions in removal -- there's
- # nothing more we can do.
- log.exception(
- "Device release failed: %s; %s; %s; %s" %
- (self.info['name'], n, d, str(ex)))
- t.commit()
-
+ while True:
+ t = xstransact("%s/device" % self.path)
+ for n in controllerClasses.keys():
+ for d in t.list(n):
+ try:
+ t.remove(d)
+ except ex:
+ # Log and swallow any exceptions in removal --
+ # there's nothing more we can do.
+ log.exception(
+ "Device release failed: %s; %s; %s; %s" %
+ (self.info['name'], n, d, str(ex)))
+ if t.commit():
+ break
def eventChannel(self, path=None):
"""Create an event channel to the domain.
compulsory to use it; subclasses may prefer to allocate IDs based upon
the device configuration instead.
"""
- path = self.frontendMiscPath()
- t = xstransact(path)
- try:
- result = t.read("nextDeviceID")
- if result:
- result = int(result)
- else:
- result = 1
- t.write("nextDeviceID", str(result + 1))
- t.commit()
- return result
- except:
- t.abort()
- raise
+ while True:
+ path = self.frontendMiscPath()
+ t = xstransact(path)
+ try:
+ result = t.read("nextDeviceID")
+ if result:
+ result = int(result)
+ else:
+ result = 1
+ t.write("nextDeviceID", str(result + 1))
+ if t.commit():
+ return result
+ except:
+ t.abort()
+ raise
## private:
(', while writing %s : %s' % (str(path),
str(data))))
- def begin(self, path):
- self.getxs().transaction_start(path)
+ def begin(self):
+ self.getxs().transaction_start()
def commit(self, abandon=False):
self.getxs().transaction_end(abort=abandon)
def __init__(self, path):
self.in_transaction = False
self.path = path.rstrip("/")
- while True:
- try:
- xshandle().transaction_start(path)
- self.in_transaction = True
- return
- except RuntimeError, ex:
- if ex.args[0] == errno.ENOENT and path != "/":
- path = "/".join(path.split("/")[0:-1]) or "/"
- else:
- raise
+ xshandle().transaction_start()
+ self.in_transaction = True
def __del__(self):
if self.in_transaction:
t = cls(path)
try:
v = t.read(*args)
- t.commit()
- return v
- except RuntimeError, ex:
t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ return v
except:
t.abort()
raise
t = cls(path)
try:
t.write(*args, **opts)
- t.commit()
- return
- except RuntimeError, ex:
- t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ if t.commit():
+ return
except:
t.abort()
raise
t = cls(path)
try:
t.remove(*args)
- t.commit()
- return
- except RuntimeError, ex:
- t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ if t.commit():
+ return
except:
t.abort()
raise
t = cls(path)
try:
v = t.list(*args)
- t.commit()
- return v
- except RuntimeError, ex:
- t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ if t.commit():
+ return v
except:
t.abort()
raise
t = cls(path)
try:
v = t.gather(*args)
- t.commit()
- return v
- except RuntimeError, ex:
- t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ if t.commit():
+ return v
except:
t.abort()
raise
t = cls(path)
try:
v = t.store(*args)
- t.commit()
- return v
- except RuntimeError, ex:
- t.abort()
- if ex.args[0] == errno.ETIMEDOUT:
- pass
- else:
- raise
+ if t.commit():
+ return v
except:
t.abort()
raise
#include <stdlib.h>
#include <string.h>
#include <xs.h>
+#include <errno.h>
static void
usage(const char *progname)
}
#endif
- /* XXX maybe find longest common prefix */
- success = xs_transaction_start(xsh, "/");
+ again:
+ success = xs_transaction_start(xsh);
if (!success)
errx(1, "couldn't start transaction");
out:
success = xs_transaction_end(xsh, ret ? true : false);
- if (!success)
+ if (!success) {
+ if (ret == 0 && errno == EAGAIN)
+ goto again;
errx(1, "couldn't end transaction");
-
+ }
return ret;
}
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
- * Returns false on failure, which indicates an error: transactions will
- * not fail spuriously.
+ * Returns false on failure: if errno == EAGAIN, you have to restart
+ * transaction.
*/
bool xs_transaction_end(struct xs_handle *h, bool abort);
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
+#include <stdarg.h>
#include "xs_lib.h"
#include "tdb.h"
projects / xen.git / commitdiff